/*
 * @Author: Await
 * @Date: 2025-05-10 09:25:00
 * @LastEditors: Await
 * @LastEditTime: 2025-05-10 09:25:00
 * @Description: 图表实例管理Hook - 修复版本
 */

import { useState, useEffect, useRef, useCallback } from 'react';
import * as echarts from 'echarts';
import { UseChartParams } from './types';
import { registerTheme } from '../../../utils/chart/themeUtils';
import { is3DChartType, ensureEChartsGLLoaded } from '../../../utils/chart/3dChartUtils';
import { logDebug, logWarning } from '../../../utils/chart/commonUtils';
import { validateAndFixConfig, needsCartesianCoords, getDefaultAxisConfig } from './chartTypeUtils';
import { fallbackTo2DConfig } from './fallbackTo2DConfig';

// 扩展ECharts实例类型，添加自定义属性
interface ExtendedECharts extends echarts.ECharts {
    __previousType?: string;
}

const useChart = ({
    chartRef,
    theme,
    renderer = 'canvas',
    onChartReady,
    onEvents,
}: UseChartParams) => {
    // 图表实例状态
    const [chartInstance, setChartInstance] = useState<echarts.ECharts | null>(null);

    // 跟踪最后一次3D图表状态
    const last3DChartRef = useRef<boolean>(false);

    // 跟踪初始化次数，防止无限循环
    const initCountRef = useRef(0);

    // 上一次实例引用
    const prevInstanceRef = useRef<echarts.ECharts | null>(null);

    // 最后一次主题引用
    const themeRef = useRef<string | object | undefined>(theme);

    // 最后一次渲染器引用
    const rendererRef = useRef<'canvas' | 'svg'>(renderer as 'canvas' | 'svg');

    // 最后使用的图表类型
    const chartTypeRef = useRef<string>('');

    /**
     * 从当前实例获取图表类型
     */
    const getChartTypeFromRef = (): string => {
        if (chartInstance) {
            try {
                const currentOption = chartInstance.getOption();
                if (currentOption && currentOption.series && Array.isArray(currentOption.series) && currentOption.series.length > 0) {
                    return (currentOption.series[0] as any).type || '';
                }
            } catch (e) {
                // 忽略错误
            }
        }
        return chartTypeRef.current;
    };

    /**
     * 重建图表实例，完全销毁当前实例并创建新实例
     * 用于在2D和3D图表类型之间切换时确保干净的图表环境
     */
    const recreateInstance = useCallback(async (): Promise<echarts.ECharts | null> => {
        // 最大重试次数
        const MAX_RETRY_COUNT = 3;
        // 跟踪重试计数
        let retryCount = 0;

        // 实际重建函数，支持重试
        const attemptRecreate = async (): Promise<echarts.ECharts | null> => {
            if (!chartRef.current) {
                console.warn('[重建] chartRef.current不存在，无法重建实例');
                return Promise.resolve(null);
            }

            // 记录当前状态，用于恢复
            const currentTheme = themeRef.current || theme;
            const currentRenderer = rendererRef.current || renderer;
            let actualTheme = currentTheme === 'default' ? undefined : currentTheme;

            // 检测是否从3D切换到2D
            const was3D = last3DChartRef.current;

            // 更新3D状态跟踪（如果是从3D切换到2D，需要特殊处理）
            const needsSpecialHandling = was3D && !is3DChartType(getChartTypeFromRef());

            console.log('[重建] 开始重建图表实例', {
                theme: actualTheme,
                renderer: currentRenderer,
                was3D,
                needsSpecialHandling,
                retryCount
            });

            // 清理现有实例
            if (chartInstance && !chartInstance.isDisposed()) {
                try {
                    console.log('[重建] 销毁现有图表实例');
                    chartInstance.clear();
                    chartInstance.dispose();
                } catch (e) {
                    console.error('[重建] 销毁现有实例失败:', e);
                }
            }

            // 强制清除所有ECharts实例
            try {
                const echarts = (window as any).echarts;
                if (echarts && typeof echarts.dispose === 'function') {
                    console.log('[重建] 执行echarts全局清理');
                    // 使用更安全的方式清理实例
                    try {
                        // 首先尝试获取所有实例
                        if (echarts.getInstanceByDom && Object.values(echarts.instances || {}).length > 0) {
                            // 逐个清理实例，而不是使用全局dispose
                            Object.values(echarts.instances || {}).forEach((instance: any) => {
                                if (instance && !instance.isDisposed && !instance.isDisposed()) {
                                    try {
                                        instance.dispose();
                                    } catch (err) {
                                        console.warn('[重建] 无法清理单个实例:', err);
                                    }
                                }
                            });
                            console.log('[重建] 已清理所有实例');
                        } else {
                            // 如果无法获取实例，使用全局dispose作为后备方案
                            // 但跳过当getAttribute可能失败的情况
                            try {
                                echarts.dispose();
                            } catch (err) {
                                console.warn('[重建] 全局dispose失败:', err);
                            }
                        }
                    } catch (err) {
                        console.warn('[重建] 实例清理过程中出现错误:', err);
                    }
                }
            } catch (e) {
                console.warn('[重建] 全局清理失败:', e);
            }

            // 清空容器内容
            const container = chartRef.current;
            if (container) {
                // 保存原始样式
                const originalStyle = {
                    display: container.style.display,
                    visibility: container.style.visibility,
                    width: container.style.width,
                    height: container.style.height
                };

                // 强制设置活跃样式，确保容器在DOM中激活
                container.style.display = 'block';
                container.style.visibility = 'visible';

                // 清空容器
                console.log('[重建] 清空容器内容');
                container.innerHTML = '';

                // 确保容器样式正确，使用更强制的方式设置尺寸
                container.style.width = originalStyle.width || '100%';
                container.style.height = originalStyle.height || '100%';

                // 对于从3D到2D的切换，设置更明确的容器尺寸
                if (needsSpecialHandling) {
                    container.style.width = '100%';
                    container.style.height = '400px';
                    // 设置绝对最小尺寸，确保容器始终有效
                    container.style.minWidth = '300px';
                    container.style.minHeight = '200px';
                }

                // 强制浏览器重新计算布局
                container.getBoundingClientRect();

                // 如果是从3D切换到2D，增加额外延迟
                // 增加延迟时间，确保DOM和样式完全更新
                const delay = needsSpecialHandling ? 300 : 150;

                // 在DOM更新后延迟创建新实例
                await new Promise(resolve => setTimeout(resolve, delay));

                try {
                    // 创建新实例前确保DOM元素已就绪
                    if (container.clientWidth === 0 || container.clientHeight === 0) {
                        console.warn('[重建] 容器尺寸无效，强制设置默认尺寸');
                        // 使用更强制的尺寸设置
                        container.style.width = '400px';
                        container.style.height = '300px';
                        container.style.minWidth = '300px';
                        container.style.minHeight = '200px';
                        // 强制进行一次布局计算
                        container.getBoundingClientRect();

                        // 确认尺寸是否有效
                        if (container.clientWidth === 0 || container.clientHeight === 0) {
                            console.error('[重建] 即使强制设置尺寸后容器仍无效:', {
                                clientWidth: container.clientWidth,
                                clientHeight: container.clientHeight
                            });

                            // 最后尝试使用内联样式直接设置
                            container.setAttribute('style',
                                'display:block !important; width:400px !important; height:300px !important;');
                            container.getBoundingClientRect();
                        }
                    }

                    // 创建新实例
                    console.log('[重建] 创建新图表实例，容器尺寸:', {
                        width: container.clientWidth,
                        height: container.clientHeight,
                        offsetWidth: container.offsetWidth,
                        offsetHeight: container.offsetHeight
                    });

                    // 确保3D组件状态正确
                    if (is3DChartType(getChartTypeFromRef())) {
                        // 如果新图表是3D图表，确保ECharts GL已加载
                        console.log('[重建] 当前是3D图表，确保GL库已加载');
                        try {
                            await ensureEChartsGLLoaded(); // 如果之前是3D，强制重载
                        } catch (e) {
                            console.warn('[重建] 加载GL库失败:', e);
                        }
                    } else if (was3D) {
                        // 如果从3D切换到2D，确保GL组件已完全清理
                        console.log('[重建] 从3D切换到2D，确保GL组件已清理');
                        try {
                            const echarts = (window as any).echarts;
                            if (echarts && echarts.gl) {
                                delete echarts.gl;
                                console.log('[重建] 已清理echarts.gl对象');
                            }
                        } catch (e) {
                            console.warn('[重建] 清理GL组件失败:', e);
                        }

                        // 设置当前状态为非3D
                        last3DChartRef.current = false;
                    }

                    // 使用Promise + setTimeout代替requestAnimationFrame以获得更可靠的行为
                    return new Promise<echarts.ECharts | null>((resolve) => {
                        // 从3D切换到2D使用更长的延迟
                        const initDelay = needsSpecialHandling ? 200 : 50;

                        setTimeout(() => {
                            try {
                                // 最后一次检查容器是否有效
                                if (!container || !document.body.contains(container)) {
                                    console.error('[重建] 容器已不在DOM中');
                                    resolve(null);
                                    return;
                                }

                                // 从3D切换到2D时，使用SVG渲染器可能更稳定
                                // 对于3D到2D的切换，默认使用SVG渲染器，更稳定
                                const preferredRenderer = needsSpecialHandling ? 'svg' : currentRenderer;

                                console.log(`[重建] 使用渲染器: ${preferredRenderer}`);

                                // 初始化参数
                                const initParams = {
                                    renderer: preferredRenderer as 'canvas' | 'svg',
                                    devicePixelRatio: window.devicePixelRatio || 1,
                                    width: container.clientWidth || 400,
                                    height: container.clientHeight || 300
                                };

                                console.log('[重建] 初始化参数:', initParams);

                                const newChart = echarts.init(container, actualTheme as string, initParams);

                                // 绑定事件
                                if (onEvents) {
                                    Object.keys(onEvents).forEach(eventName => {
                                        newChart.on(eventName, (params) => onEvents[eventName](params));
                                    });
                                }

                                // 更新状态
                                setChartInstance(newChart);
                                prevInstanceRef.current = newChart;

                                // 通知外部实例已准备好
                                if (onChartReady) {
                                    onChartReady(newChart);
                                }

                                // 强制一次resize
                                if (!newChart.isDisposed()) {
                                    newChart.resize();
                                }

                                console.log('[重建] 图表实例重建成功');

                                // 触发自定义事件以允许其他组件响应实例重建
                                window.dispatchEvent(new CustomEvent('echarts-instance-recreated', {
                                    detail: {
                                        timestamp: Date.now(),
                                        is3D: is3DChartType(getChartTypeFromRef()),
                                        from3D: was3D
                                    }
                                }));

                                resolve(newChart);
                            } catch (e) {
                                console.error('[重建] 创建新实例失败:', e);
                                // 在此不直接返回null，而是让外层重试逻辑处理
                                resolve(null);
                            }
                        }, initDelay);
                    });
                } catch (e) {
                    console.error('[重建] 创建新实例过程中出现错误:', e);
                    return null;
                }
            } else {
                console.error('[重建] 容器不存在');
                return null;
            }
        };

        // 执行重试逻辑
        while (retryCount < MAX_RETRY_COUNT) {
            const instance = await attemptRecreate();
            if (instance) {
                // 成功创建实例，返回
                return instance;
            } else {
                // 失败，增加重试计数
                retryCount++;
                console.log(`[重建] 第${retryCount}次重试...`);
                // 在重试前等待更长时间
                await new Promise(resolve => setTimeout(resolve, 300));
            }
        }

        // 所有重试都失败了
        console.error(`[重建] 在${MAX_RETRY_COUNT}次尝试后仍无法创建图表实例`);
        return null;
    }, [chartRef, chartInstance, theme, renderer, onChartReady, onEvents]);

    // 初始化图表 - 只在组件挂载时执行一次
    useEffect(() => {
        // 防止无限循环
        if (initCountRef.current > 0) {
            console.log('图表已初始化，跳过重复初始化');
            return;
        }

        // 增加初始化计数
        initCountRef.current += 1;

        if (!chartRef.current) return;

        // 清理已有实例
        const cleanup = () => {
            if (chartInstance && !chartInstance.isDisposed()) {
                chartInstance.dispose();
            }
        };

        cleanup();

        // 处理主题
        let chartTheme = theme === 'default' ? undefined : theme;
        if (chartTheme && typeof chartTheme === 'object') {
            const registeredTheme = registerTheme(chartTheme);
            chartTheme = registeredTheme;
        }

        // 创建新实例
        try {
            console.log('初始化图表实例，主题:', chartTheme);

            // 如果DOM元素上有lastChart3D标记，确保彻底清理
            if ((chartRef.current as any).lastChart3D) {
                console.log('检测到上一个图表为3D图表，执行彻底清理');
                chartRef.current.innerHTML = '';
            }

            // 检查DOM元素是否已经有图表实例
            const existingInstance = echarts.getInstanceByDom(chartRef.current);
            if (existingInstance) {
                console.log('DOM元素已有图表实例，复用现有实例');
                existingInstance.dispose();
            }

            // 确保容器有明确的尺寸和样式
            console.log('设置图表容器初始样式');
            chartRef.current.style.display = 'block';
            chartRef.current.style.visibility = 'visible';
            chartRef.current.style.minWidth = '300px';
            chartRef.current.style.minHeight = '250px';

            // 如果实际尺寸为0，设置绝对尺寸
            if (chartRef.current.clientWidth === 0 || chartRef.current.clientHeight === 0) {
                console.log('初始化前检测到容器尺寸为0，强制设置绝对尺寸');
                chartRef.current.style.width = '400px';
                chartRef.current.style.height = '300px';
            }

            console.log('创建图表实例, 容器尺寸:', {
                width: chartRef.current.clientWidth,
                height: chartRef.current.clientHeight
            });

            const newChart = echarts.init(chartRef.current, chartTheme as string, {
                renderer,
                width: chartRef.current.clientWidth || 400,
                height: chartRef.current.clientHeight || 300,
            });

            // 绑定事件
            if (onEvents) {
                Object.keys(onEvents).forEach(eventName => {
                    newChart.on(eventName, (params) => onEvents[eventName](params));
                });
            }

            // 保存到引用并更新状态
            prevInstanceRef.current = newChart;
            setChartInstance(newChart);

            // 强制一次resize确保尺寸正确
            setTimeout(() => {
                if (!newChart.isDisposed()) {
                    console.log('初始化时强制执行resize');
                    newChart.resize();

                    // 触发初始渲染事件
                    const initEvent = new CustomEvent('chart-init-complete', {
                        detail: { chart: newChart, timestamp: Date.now() }
                    });
                    window.dispatchEvent(initEvent);
                }
            }, 100);

            if (onChartReady) {
                onChartReady(newChart);
            }

            console.log('图表实例创建成功');
        } catch (error) {
            console.error('初始化图表失败:', error);
        }

        // 组件卸载时清理图表实例
        return cleanup;
        // 只在首次挂载和卸载时执行，避免依赖项变化导致重复创建实例
    }, []);

    // 跟踪上一次应用的配置对象的引用，避免重复应用同一配置
    const lastOptionRef = useRef<any>(null);

    // 应用选项前预处理函数
    const preprocessOption = (option: any): any => {
        if (!option) return option;

        try {
            // 创建配置副本，避免修改原始对象
            const processedOption = JSON.parse(JSON.stringify(option));

            // 确保有全局类型
            if (!processedOption.type) {
                // 如果series存在并且第一个series有type，使用它作为全局type
                if (Array.isArray(processedOption.series) && processedOption.series.length > 0 && processedOption.series[0]?.type) {
                    processedOption.type = processedOption.series[0].type;
                } else if (typeof processedOption.series === 'object' && processedOption.series?.type) {
                    processedOption.type = processedOption.series.type;
                } else {
                    // 默认为基础图表类型
                    processedOption.type = 'line';
                }
                console.log(`配置缺少全局type，设置为: ${processedOption.type}`);
            }

            // 确保坐标轴配置是数组格式
            if (processedOption.xAxis && !Array.isArray(processedOption.xAxis)) {
                processedOption.xAxis = [processedOption.xAxis];
            }

            if (processedOption.yAxis && !Array.isArray(processedOption.yAxis)) {
                processedOption.yAxis = [processedOption.yAxis];
            }

            // 确保series存在且为数组
            if (!processedOption.series) {
                // 如果没有series，创建一个默认series
                processedOption.series = [{
                    type: processedOption.type || 'line',
                    data: [],
                    name: '默认数据'
                }];
                console.log('配置缺少series，创建默认series');
            } else if (!Array.isArray(processedOption.series)) {
                // 如果series不是数组，转换为数组
                processedOption.series = [processedOption.series];
            }

            // 移除series中的null或undefined项
            processedOption.series = processedOption.series.filter((item: any) => item != null);

            // 确保系列中每项都有正确的type
            processedOption.series.forEach((series: any, index: number) => {
                if (!series.type) {
                    series.type = processedOption.type || 'line';
                    console.log(`系列[${index}]缺少type属性，应用默认类型: ${series.type}`);
                }

                // 确保每个系列都有name，方便调试
                if (!series.name) {
                    series.name = `系列${index + 1}`;
                }

                // 确保data存在
                if (!series.data) {
                    series.data = [];
                }
            });

            // 处理空series数组的情况
            if (processedOption.series.length === 0) {
                processedOption.series.push({
                    type: processedOption.type || 'line',
                    data: [],
                    name: '默认数据'
                });
                console.log('series为空数组，添加默认系列');
            }

            return processedOption;
        } catch (error) {
            console.error('预处理配置失败:', error);
            // 发生错误时返回原始配置
            return option;
        }
    };

    // 设置选项的函数
    // 移除时间限制，允许立即切换
    // 用于跟踪已应用的配置，避免重复应用
    const appliedConfigsRef = useRef<Set<string>>(new Set());

    // 深度比较两个对象是否相等
    const isEqual = (a: any, b: any): boolean => {
        if (a === b) return true;
        if (a === null || b === null) return false;
        if (typeof a !== 'object' || typeof b !== 'object') return a === b;

        const keysA = Object.keys(a);
        const keysB = Object.keys(b);

        if (keysA.length !== keysB.length) return false;

        return keysA.every(key => isEqual(a[key], b[key]));
    };

    const setOption = useCallback((option: any, notMerge = false) => {
        if (!chartInstance || chartInstance.isDisposed()) {
            return;
        }

        // 确保选项是有效对象
        if (!option || typeof option !== 'object') {
            console.warn('无效的图表配置，跳过更新');
            return;
        }

        // 生成配置指纹以检测重复配置
        let configDigest = '';
        try {
            // 创建简化版的配置用于指纹生成
            const simplifiedOption = {
                type: option.type,
                series: option.series && Array.isArray(option.series) ?
                    option.series.map((s: any) => ({
                        type: s.type,
                        dataCount: Array.isArray(s.data) ? s.data.length : 0
                    })) : [],
                // 添加其他关键属性
                time: Date.now() // 时间戳，确保不同时间的相同配置仍被应用
            };

            configDigest = JSON.stringify(simplifiedOption);

            // 检查最近是否已应用过此配置(10秒内)
            if (appliedConfigsRef.current.has(configDigest)) {
                console.log('[优化] 跳过短时间内重复的相同配置');
                return;
            }

            // 添加到已应用配置集合，设置过期时间
            appliedConfigsRef.current.add(configDigest);
            setTimeout(() => {
                appliedConfigsRef.current.delete(configDigest);
            }, 10000); // 10秒后从缓存中删除
        } catch (e) {
            // 忽略指纹生成错误
        }

        // 与上次配置进行深度比较，避免重复应用相同配置
        if (lastOptionRef.current && isEqual(lastOptionRef.current, option)) {
            console.log('[优化] 配置完全相同，跳过更新');
            return;
        }

        // 确保在setTimeout中调用，避免在主进程中调用setOption
        if (typeof window !== 'undefined' && typeof setTimeout === 'function') {
            setTimeout(() => {
                // 在setTimeout回调中再次检查实例是否有效
                if (!chartInstance || chartInstance.isDisposed()) return;

                // 记录图表容器尺寸信息，帮助诊断问题
                if (chartRef.current) {
                    console.log('图表容器尺寸:', {
                        clientWidth: chartRef.current.clientWidth,
                        clientHeight: chartRef.current.clientHeight,
                        offsetWidth: chartRef.current.offsetWidth,
                        offsetHeight: chartRef.current.offsetHeight
                    });
                }

                let finalOption = option;
                let is3DChart = false;

                // 检测是否是3D图表类型
                if (option.type && is3DChartType(option.type)) {
                    is3DChart = true;
                    console.log('检测到3D图表类型:', option.type);

                    // 更新图表类型引用
                    chartTypeRef.current = option.type;

                    // 特殊处理3D柱状图，优化光照和材质配置
                    if (option.type === 'bar3D') {
                        console.log('特殊处理3D柱状图配置');

                        try {
                            // 创建深拷贝避免修改原始配置
                            finalOption = JSON.parse(JSON.stringify(option));

                            // 优化光照配置
                            if (!finalOption.light) {
                                finalOption.light = {};
                            }

                            if (!finalOption.light.main) {
                                finalOption.light.main = {};
                            }

                            // 调整主光源
                            finalOption.light.main.intensity = 1.5;  // 增强光照强度
                            finalOption.light.main.shadow = true;
                            finalOption.light.main.alpha = 40;  // 调整光源角度
                            finalOption.light.main.beta = 30;

                            // 增强环境光
                            if (!finalOption.light.ambient) {
                                finalOption.light.ambient = {};
                            }
                            finalOption.light.ambient.intensity = 0.5;  // 增加环境光强度，减少阴影

                            // 确保每个系列都有合适的材质设置
                            if (finalOption.series && Array.isArray(finalOption.series)) {
                                finalOption.series.forEach((series: any) => {
                                    if (!series.itemStyle) {
                                        series.itemStyle = {};
                                    }

                                    // 启用真实材质渲染
                                    series.shading = 'realistic';

                                    // 设置材质属性
                                    series.itemStyle.opacity = 0.8;
                                    series.itemStyle.metalness = 0.4;
                                    series.itemStyle.roughness = 0.5;
                                });
                            }
                        } catch (e) {
                            console.error('优化3D柱状图配置失败:', e);
                            finalOption = option;  // 回退到原始配置
                        }
                    }
                } else {
                    // 更新图表类型引用
                    chartTypeRef.current = option.type || (Array.isArray(option.series) && option.series.length > 0 ? option.series[0].type : '');
                }

                // 检测是否从3D切换到2D
                const isChangingFrom3Dto2D = !is3DChart && last3DChartRef.current;

                // 如果是3D图表，确保GL库已加载
                if (is3DChart) {
                    // 记录3D状态
                    last3DChartRef.current = true;

                    // 启动异步加载过程
                    console.log('启动3D图表加载流程');
                    // 直接加载GL库，无需等待
                    ensureEChartsGLLoaded().then(success => {
                        if (success) {
                            console.log('3D库加载成功，应用配置到图表');
                            try {
                                // 标记DOM元素为3D图表
                                if (chartRef.current) {
                                    (chartRef.current as any).lastChart3D = true;
                                }

                                // 确保3D配置中的series都有有效的type
                                if (finalOption && finalOption.series) {
                                    if (Array.isArray(finalOption.series)) {
                                        finalOption.series = finalOption.series.filter((item: any) => item != null);

                                        finalOption.series.forEach((series: any, index: number) => {
                                            if (!series.type) {
                                                // 对于3D图表，确保使用正确的3D系列类型
                                                series.type = finalOption.type || 'scatter3D';
                                                console.log(`3D系列[${index}]缺少type属性，应用默认3D类型: ${series.type}`);
                                            }
                                        });
                                    } else if (typeof finalOption.series === 'object' && finalOption.series !== null) {
                                        if (!finalOption.series.type) {
                                            finalOption.series.type = finalOption.type || 'scatter3D';
                                        }
                                    }

                                    if (Array.isArray(finalOption.series) && finalOption.series.length === 0) {
                                        // 为空series添加默认3D系列
                                        finalOption.series.push({
                                            type: finalOption.type || 'scatter3D',
                                            data: []
                                        });
                                    }
                                }

                                // 确保3D图表的type属性存在
                                if (!finalOption.type) {
                                    finalOption.type = 'scatter3D';
                                }

                                // 减少详细日志输出，只保留必要信息
                                console.log('应用3D配置到图表');

                                // 应用配置到图表
                                chartInstance.setOption(finalOption, notMerge);
                                // 保存应用的配置引用
                                lastOptionRef.current = { ...finalOption };

                                console.log('3D图表配置应用成功');

                                // 对3D柱状图应用延迟resize，确保正确渲染
                                if (finalOption.type === 'bar3D') {
                                    setTimeout(() => {
                                        if (chartInstance && !chartInstance.isDisposed()) {
                                            console.log('对3D柱状图执行延迟resize');
                                            chartInstance.resize();
                                        }
                                    }, 200);
                                }
                            } catch (error) {
                                console.error('3D图表配置应用失败:', error);
                                // 尝试回退到2D模式
                                try {
                                    console.log('尝试回退到2D模式');
                                    const fallbackOption = fallbackTo2DConfig(finalOption);
                                    chartInstance.setOption(fallbackOption, true);
                                    lastOptionRef.current = { ...fallbackOption };
                                } catch (fallbackError) {
                                    console.error('回退到2D模式失败:', fallbackError);
                                }
                            }
                        } else {
                            console.error('3D库加载失败，尝试回退到2D模式');
                            // 尝试回退到2D模式
                            try {
                                const fallbackOption = fallbackTo2DConfig(finalOption);
                                chartInstance.setOption(fallbackOption, true);
                                lastOptionRef.current = { ...fallbackOption };
                            } catch (fallbackError) {
                                console.error('回退到2D模式失败:', fallbackError);
                            }
                        }
                    }).catch(error => {
                        console.error('3D库加载过程异常:', error);
                    });
                } else {
                    // 非3D图表，直接应用配置
                    try {
                        // 特殊处理：从3D切换到2D
                        if (isChangingFrom3Dto2D) {
                            console.log('从3D切换到2D图表，执行特殊处理');

                            // 重置3D状态
                            last3DChartRef.current = false;
                            if (chartRef.current) {
                                (chartRef.current as any).lastChart3D = false;
                            }

                            // 强制重建实例可能是最可靠的解决方案
                            try {
                                recreateInstance().then(newInstance => {
                                    if (newInstance && !newInstance.isDisposed()) {
                                        console.log('3D→2D: 完成实例重建，应用配置');

                                        // 确保配置中的series都有有效的type属性
                                        const processedOption = preprocessOption(finalOption);

                                        // 使用requestAnimationFrame确保在下一渲染帧应用配置
                                        requestAnimationFrame(() => {
                                            if (newInstance && !newInstance.isDisposed()) {
                                                newInstance.setOption(processedOption, true);
                                                newInstance.resize();
                                                lastOptionRef.current = { ...processedOption };
                                            }
                                        });
                                    }
                                });

                                // 已安排后续处理，提前返回
                                return;
                            } catch (e) {
                                console.error('3D→2D重建实例失败，尝试直接应用配置:', e);
                            }
                        } else {
                            // 普通2D图表切换
                            // 重置3D状态
                            last3DChartRef.current = false;
                            if (chartRef.current) {
                                (chartRef.current as any).lastChart3D = false;
                            }
                        }

                        console.log('应用非3D图表配置');

                        // 确保配置中的series都有有效的type属性
                        if (finalOption && finalOption.series) {
                            // 处理series为数组的情况
                            if (Array.isArray(finalOption.series)) {
                                // 过滤掉null和undefined
                                finalOption.series = finalOption.series.filter((item: any) => item != null);

                                // 确保每个series都有type属性
                                finalOption.series.forEach((series: any, index: number) => {
                                    if (!series.type) {
                                        // 如果series没有type，使用配置的全局type或默认为'line'
                                        const defaultType = finalOption.type || 'line';
                                        console.log(`系列[${index}]缺少type属性，应用默认类型: ${defaultType}`);
                                        series.type = defaultType;
                                    }
                                });
                            }
                            // 处理series为单个对象的情况
                            else if (typeof finalOption.series === 'object' && finalOption.series !== null) {
                                if (!finalOption.series.type) {
                                    finalOption.series.type = finalOption.type || 'line';
                                    console.log(`系列对象缺少type属性，应用默认类型: ${finalOption.series.type}`);
                                }
                            }
                        }

                        // 处理series为空数组的情况
                        if (Array.isArray(finalOption.series) && finalOption.series.length === 0) {
                            console.log('系列为空数组，添加默认数据系列');

                            // 添加一个默认系列，避免Unknown series错误
                            finalOption.series.push({
                                type: finalOption.type || 'line',
                                data: []
                            });
                        }

                        // 确保配置对象完整性
                        finalOption = preprocessOption(finalOption);

                        console.log('处理后的最终配置:', {
                            type: finalOption.type,
                            seriesCount: Array.isArray(finalOption.series) ? finalOption.series.length : 1,
                            seriesTypes: Array.isArray(finalOption.series)
                                ? finalOption.series.map((s: any) => s.type)
                                : [finalOption.series?.type]
                        });

                        chartInstance.setOption(finalOption, notMerge);
                        lastOptionRef.current = { ...finalOption };
                        console.log('非3D图表配置应用成功');

                        // 3D→2D切换后执行额外的resize，帮助图表完成渲染
                        if (isChangingFrom3Dto2D) {
                            setTimeout(() => {
                                if (chartInstance && !chartInstance.isDisposed()) {
                                    console.log('从3D切换后执行额外的resize');
                                    chartInstance.resize();
                                }
                            }, 300);
                        }
                    } catch (error) {
                        console.error('应用图表配置失败:', error);
                    }
                }
            }, 0);
        } else {
            // 同步模式 - 通常仅在SSR环境下使用
            try {
                chartInstance.setOption(option, notMerge);
                lastOptionRef.current = { ...option };
            } catch (error) {
                console.error('同步模式下应用图表配置失败:', error);
            }
        }
    }, [chartInstance]);

    // 调整图表大小的函数
    const resize = useCallback(() => {
        if (chartInstance && !chartInstance.isDisposed() && chartRef.current) {
            try {
                console.log('手动调整图表大小');
                chartInstance.resize();
            } catch (error) {
                console.error('调整图表大小失败:', error);
            }
        }
    }, [chartInstance]);

    // 显示加载动画
    const showLoading = useCallback((text = '加载中...') => {
        if (chartInstance && !chartInstance.isDisposed()) {
            chartInstance.showLoading({
                text,
                color: '#5470c6',
                textColor: '#000',
                maskColor: 'rgba(255, 255, 255, 0.8)'
            });
        }
    }, [chartInstance]);

    // 隐藏加载动画
    const hideLoading = useCallback(() => {
        if (chartInstance && !chartInstance.isDisposed()) {
            chartInstance.hideLoading();
        }
    }, [chartInstance]);

    // 导出当前图表的函数
    const getDataURL = useCallback((opts?: any) => {
        if (!chartInstance || chartInstance.isDisposed()) {
            return '';
        }
        return chartInstance.getDataURL(opts);
    }, [chartInstance]);

    // 暴露是否为3D图表的属性
    const is3D = last3DChartRef.current;

    // 返回图表实例和控制函数
    return {
        chartInstance,
        setOption,
        showLoading,
        hideLoading,
        resize,
        getDataURL,
        is3D: last3DChartRef.current,
        recreateInstance
    };
};

// 使用默认导出
export default useChart;
